{
	"info": {
      "_postman_id": "1b12f39d-a514-42d9-99a1-2d2f4026b8e8",
      "name": "\"Explore with me\" API статистика",
      "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
      "_exporter_id": "23073145",
      "_collection_link": "https://universal-shadow-295426.postman.co/workspace/My-Workspace~4200f6aa-0504-44b1-8a1d-707d0dcbd5ce/collection/23073145-1b12f39d-a514-42d9-99a1-2d2f4026b8e8?action=share&creator=23073145&source=collection_link"
    },
	"item": [
      {
        "name": "Сохранение информации о том, что к эндпоинту был запрос",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                "const main = async () => {\r",
                "    const api = new API(pm);\r",
                "    const rnd = new RandomUtils();\r",
                "\r",
                "    let post;\r",
                "    try {\r",
                "        post = rnd.getPost();\r",
                "    } catch(err) {\r",
                "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                "    }\r",
                "\r",
                "    pm.request.body.update({\r",
                "        mode: 'raw',\r",
                "        raw: JSON.stringify(post),\r",
                "        options: { raw: { language: 'json' } }\r",
                "    });\r",
                "};\r",
                "\r",
                "const interval = setInterval(() => {}, 1000);\r",
                "\r",
                "setTimeout(async () => \r",
                "    {\r",
                "        try {\r",
                "            await main();\r",
                "        } catch (e) {\r",
                "            console.error(e);\r",
                "        } finally {\r",
                "            clearInterval(interval);\r",
                "        }\r",
                "    },  \r",
                "    100 \r",
                ");"
              ],
              "type": "text/javascript"
            }
          },
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                "    pm.response.to.have.status(201);\r",
                "});\r",
                ""
              ],
              "type": "text/javascript"
            }
          }
        ],
        "request": {
          "method": "POST",
          "header": [
            {
              "key": "Content-Type",
              "value": "application/json"
            }
          ],
          "body": {
            "mode": "raw",
            "raw": "",
            "options": {
              "raw": {
                "language": "json"
              }
            }
          },
          "url": {
            "raw": "{{baseUrl}}/hit",
            "host": [
              "{{baseUrl}}"
            ],
            "path": [
              "hit"
            ]
          },
          "description": "Сохранение информации о том, что на uri конкретного сервиса был отправлен запрос пользователем. Название сервиса, uri и ip пользователя указаны в теле запроса."
        },
        "response": []
      },
      {
        "name": "Получение статистики по посещениям. Обратите внимание: значение даты и времени нужно закодировать (например используя java.net.URLEncoder.encode)(Тест на /events/{id})",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                "const main = async () => {\r",
                "    const api = new API(pm);\r",
                "    const rnd = new RandomUtils();\r",
                "\r",
                "    try {      \r",
                "        const user = await api.addUser(rnd.getUser());\r",
                "        const category = await api.addCategory(rnd.getCategory());\r",
                "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                "        event = await api.publishEvent(event.id);\r",
                "        pm.collectionVariables.set(\"uri\", '/events/' + event.id);\r",
                "\r",
                "        pm.sendRequest({\r",
                "            url : \"http://localhost:8080/events/\" + event.id,\r",
                "            method : \"GET\",\r",
                "            header: { \"Content-Type\": \"application/json\" }\r",
                "        }, (error, response) => {\r",
                "            pm.sendRequest({\r",
                "                url : \"http://localhost:9090/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris=/events/\" + event.id.toString() + \"&unique=false\",\r",
                "                method : \"GET\",\r",
                "                header: { \"Content-Type\": \"application/json\" }\r",
                "            }, (error, response) => {\r",
                "                pm.collectionVariables.set('source', response.json());\r",
                "                pm.sendRequest({\r",
                "                    url : \"http://localhost:8080/events/\" + event.id,\r",
                "                    method : \"GET\",\r",
                "                    header: { \"Content-Type\": \"application/json\" }\r",
                "                });\r",
                "            });\r",
                "        });\r",
                "        \r",
                "    } catch(err) {\r",
                "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                "    }\r",
                "};\r",
                "\r",
                "const interval = setInterval(() => {}, 1000);\r",
                "\r",
                "setTimeout(async () => \r",
                "    {\r",
							"        try {\r",
							"            await main();\r",
							"        } catch (e) {\r",
							"            console.error(e);\r",
							"        } finally {\r",
							"            clearInterval(interval);\r",
							"        }\r",
							"    },  \r",
							"    100 \r",
							");"
						],
						"type": "text/javascript"
					}
				},
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                "    pm.response.to.be.ok;    \r",
                "    pm.response.to.be.withBody;\r",
                "    pm.response.to.be.json;\r",
                "});\r",
                "\r",
                "const target = pm.response.json()[0];\r",
                "\r",
                "pm.test(\"Посты должны содержать поля: app, uri, hits\", function () {\r",
                "    pm.expect(target).to.have.all.keys('app', 'uri', 'hits');\r",
                "});\r",
                "\r",
                "const source = pm.collectionVariables.get(\"source\")[0];\r",
                "\r",
                "\r",
                "pm.test(\"После выполнения запроса GET /events/{id} должно увеличиться количество хитов.\", function(){\r",
                "    pm.expect(source.hits + 1).equal(target.hits, 'Количество хитов после выполнения запроса GET /events/{id} должно быть больше на 1.');\r",
                "});"
              ],
              "type": "text/javascript"
            }
          }
        ],
        "request": {
          "method": "GET",
          "header": [
            {
              "key": "Accept",
              "value": "application/json"
            }
          ],
          "url": {
            "raw": "{{baseUrl}}/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris={{uri}}&unique=false",
            "host": [
              "{{baseUrl}}"
            ],
            "path": [
              "stats"
            ],
            "query": [
              {
                "key": "start",
                "value": "2020-05-05 00:00:00",
                "description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "end",
                "value": "2035-05-05 00:00:00",
                "description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "uris",
                "value": "{{uri}}",
                "description": "Список uri для которых нужно выгрузить статистику"
              },
              {
                "key": "unique",
                "value": "false",
                "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)"
              }
            ]
          }
        },
        "response": []
      },
      {
        "name": "Тест взаимодействия сервисов",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                "const main = async () => {\r",
                "    const api = new API(pm);\r",
                "    const rnd = new RandomUtils();\r",
                "\r",
                "    try {      \r",
                "        const user = await api.addUser(rnd.getUser());\r",
                "        const category = await api.addCategory(rnd.getCategory());\r",
                "        let event1 = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                "        event1 = await api.publishEvent(event1.id);\r",
                "        let event2 = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                "        event2 = await api.publishEvent(event2.id);\r",
                "        pm.collectionVariables.set(\"uri\", '/events/' + event1.id + '&uris=/events/' + event2.id);\r",
                "\r",
                "        pm.sendRequest({\r",
                "            url : \"http://localhost:8080/events/\" + event1.id,\r",
                "            method : \"GET\",\r",
                "            header: { \"Content-Type\": \"application/json\" }\r",
                "        }, (error, response) => {\r",
                "            pm.sendRequest({\r",
                "            url : \"http://localhost:8080/events/\" + event2.id,\r",
                "            method : \"GET\",\r",
                "            header: { \"Content-Type\": \"application/json\" }\r",
                "            }, (error, response) => {\r",
                "                pm.sendRequest({\r",
                "                    url : \"http://localhost:8080/events/\" + event2.id,\r",
                "                    method : \"GET\",\r",
                "                    header: { \"Content-Type\": \"application/json\" }\r",
                "                }, (error, response) => {\r",
                "                });\r",
                "            });\r",
                "        });\r",
                "        \r",
                "    } catch(err) {\r",
                "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                "    }\r",
                "};\r",
                "\r",
                "const interval = setInterval(() => {}, 1000);\r",
                "\r",
                "setTimeout(async () => \r",
                "    {\r",
                "        try {\r",
                "            await main();\r",
                "        } catch (e) {\r",
                "            console.error(e);\r",
                "        } finally {\r",
                "            clearInterval(interval);\r",
                "        }\r",
                "    },  \r",
                "    100 \r",
                ");"
              ],
              "type": "text/javascript"
            }
          },
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                "    pm.response.to.be.ok;    \r",
                "    pm.response.to.be.withBody;\r",
                "    pm.response.to.be.json;\r",
                "});\r",
                "\r",
                "const target = pm.response.json();\r",
                "\r",
                "pm.test(\"Посты должны содержать поля: app, uri, hits\", function () {\r",
                "    pm.expect(target[0]).to.have.all.keys('app', 'uri', 'hits');\r",
                "    pm.expect(target[1]).to.have.all.keys('app', 'uri', 'hits');\r",
                "});\r",
                "\r",
                "pm.test(\"В теле ответа должна соблюдаться сортировка по убыванию количества просмотров\", function(){\r",
                "    pm.expect(target[0].hits).to.be.above(target[1].hits);\r",
                "});\r",
                "\r",
                "pm.test(\"Проверка соответствия реального количества просмотров событий и сохраненных хитов\", function(){\r",
                "    pm.expect(target[0].hits).equal(2);\r",
                "    pm.expect(target[1].hits).equal(1);\r",
                "});"
              ],
						"type": "text/javascript"
					}
				}
			],
			"request": {
				"method": "GET",
				"header": [
					{
						"key": "Accept",
						"value": "application/json"
					}
				],
				"url": {
                  "raw": "{{baseUrl}}/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris={{uri}}",
                  "host": [
                    "{{baseUrl}}"
                  ],
                  "path": [
                    "stats"
                  ],
                  "query": [
                    {
                      "key": "start",
                      "value": "2020-05-05 00:00:00",
							"description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "end",
							"value": "2035-05-05 00:00:00",
							"description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "uris",
							"value": "{{uri}}",
                          "description": "Список uri для которых нужно выгрузить статистику"
						},
						{
							"key": "uris",
							"value": "aliqua o",
							"description": "Список uri для которых нужно выгрузить статистику",
							"disabled": true
						},
                    {
                      "key": "unique",
                      "value": "false",
                      "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)",
                      "disabled": true
                    }
					]
				}
			},
			"response": []
		},
      {
        "name": "Получение статистики по посещениям. Обратите внимание: значение даты и времени нужно закодировать (например используя java.net.URLEncoder.encode)(Тест на /events)",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                "const main = async () => {\r",
                "    const api = new API(pm);\r",
                "    const rnd = new RandomUtils();\r",
                "\r",
                "    try {    \r",
                "        pm.collectionVariables.set(\"uri\", '/events');  \r",
                "        \r",
                "        pm.sendRequest({\r",
                "            url : \"http://localhost:8080/events\",\r",
                "            method : \"GET\",\r",
                "            header: { \"Content-Type\": \"application/json\" }\r",
                "        }, (error, response) => {\r",
                "            \r",
                "            pm.sendRequest({\r",
                "                url : \"http://localhost:9090/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris=/events&unique=false\",\r",
                "                method : \"GET\",\r",
                "                header: { \"Content-Type\": \"application/json\" }\r",
                "            }, (error, response) => {\r",
                "                pm.collectionVariables.set('source', response.json());\r",
                "                pm.sendRequest({\r",
                "                    url : \"http://localhost:8080/events\",\r",
                "                    method : \"GET\",\r",
                "                    header: { \"Content-Type\": \"application/json\" }\r",
                "                });\r",
                "            });\r",
                "        });\r",
                "        \r",
                "    } catch(err) {\r",
                "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                "    }\r",
                "};\r",
                "\r",
                "const interval = setInterval(() => {}, 1000);\r",
                "\r",
                "setTimeout(async () => \r",
                "    {\r",
                "        try {\r",
							"            await main();\r",
							"        } catch (e) {\r",
							"            console.error(e);\r",
							"        } finally {\r",
							"            clearInterval(interval);\r",
							"        }\r",
							"    },  \r",
							"    100 \r",
							");"
						],
						"type": "text/javascript"
					}
				},
				{
					"listen": "test",
					"script": {
						"exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json()[0];\r",
                          "\r",
                          "pm.test(\"Посты должны содержать поля: app, uri, hits\", function () {\r",
                          "    pm.expect(target).to.have.all.keys('app', 'uri', 'hits');\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get(\"source\")[0];\r",
                          "\r",
                          "\r",
                          "pm.test(\"После выполнения запроса GET /events должно увеличиться количество хитов.\", function(){\r",
                          "    pm.expect(source.hits + 1).equal(target.hits, 'Количество хитов после выполнения запроса GET /events должно быть больше на 1.');\r",
                          "});"
                        ],
						"type": "text/javascript"
					}
				}
			],
			"request": {
				"method": "GET",
				"header": [
					{
						"key": "Accept",
						"value": "application/json"
					}
				],
				"url": {
                  "raw": "{{baseUrl}}/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris={{uri}}&unique=false",
                  "host": [
                    "{{baseUrl}}"
                  ],
                  "path": [
                    "stats"
                  ],
                  "query": [
                    {
                      "key": "start",
                      "value": "2020-05-05 00:00:00",
							"description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "end",
							"value": "2035-05-05 00:00:00",
							"description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "uris",
							"value": "{{uri}}",
							"description": "Список uri для которых нужно выгрузить статистику"
						},
                    {
                      "key": "unique",
                      "value": "false",
                      "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)"
                    }
					]
				}
			},
			"response": []
		},
      {
        "name": "Получение статистики по посещениям. (Тест на опциональность и работу параметра unique)",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                "const main = async () => {\r",
                "    const api = new API(pm);\r",
                "    const rnd = new RandomUtils();\r",
                "\r",
                "    try {    \r",
                "        pm.collectionVariables.set(\"uri\", '/events');  \r",
                "        \r",
                "        pm.sendRequest({\r",
                "            url : \"http://localhost:8080/events\",\r",
                "            method : \"GET\",\r",
                "            header: { \"Content-Type\": \"application/json\" }\r",
                "        }, (error, response) => {\r",
                "            pm.sendRequest({\r",
                "                url : \"http://localhost:8080/events\",\r",
                "                method : \"GET\",\r",
                "                header: { \"Content-Type\": \"application/json\" }\r",
                "            }, (error, response) => {\r",
                "                \r",
                "                pm.sendRequest({\r",
                "                    url : \"http://localhost:9090/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris=/events&unique=true\",\r",
                "                    method : \"GET\",\r",
                "                    header: { \"Content-Type\": \"application/json\" }\r",
                "                }, (error, response) => {\r",
                "                    pm.collectionVariables.set('source', response.json());\r",
                "                });\r",
                "            });\r",
                "        });\r",
                "    } catch(err) {\r",
                "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                "    }\r",
                "};\r",
                "\r",
                "const interval = setInterval(() => {}, 1000);\r",
                "\r",
                "setTimeout(async () => \r",
                "    {\r",
                "        try {\r",
							"            await main();\r",
							"        } catch (e) {\r",
							"            console.error(e);\r",
							"        } finally {\r",
							"            clearInterval(interval);\r",
							"        }\r",
							"    },  \r",
							"    100 \r",
							");"
						],
						"type": "text/javascript"
					}
				},
				{
					"listen": "test",
					"script": {
						"exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json при запросе без опционального параметра unique\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json()[0];\r",
                          "\r",
                          "pm.test(\"Посты должны содержать поля: app, uri, hits\", function () {\r",
                          "    pm.expect(target).to.have.all.keys('app', 'uri', 'hits');\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get(\"source\")[0];\r",
                          "\r",
                          "pm.test(\"Количество уникальных просмотров с одного ip должно равняться 1\", function () {\r",
                          "    pm.expect(source.hits == 1);\r",
                          "})\r",
                          "\r",
                          "pm.test(\"Количество просмотров с одного ip должно быть больше 1\", function () {\r",
                          "    pm.expect(target.hits > 1);\r",
                          "})"
                        ],
						"type": "text/javascript"
					}
				}
			],
			"request": {
				"method": "GET",
				"header": [
					{
						"key": "Accept",
						"value": "application/json"
					}
				],
				"url": {
					"raw": "{{baseUrl}}/stats?start=2020-05-05 00:00:00&end=2035-05-05 00:00:00&uris={{uri}}",
					"host": [
						"{{baseUrl}}"
					],
					"path": [
						"stats"
					],
					"query": [
						{
							"key": "start",
							"value": "2020-05-05 00:00:00",
							"description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "end",
							"value": "2035-05-05 00:00:00",
							"description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
						},
						{
							"key": "uris",
							"value": "{{uri}}",
							"description": "Список uri для которых нужно выгрузить статистику"
						},
						{
							"key": "uris",
							"value": "aliqua o",
							"description": "Список uri для которых нужно выгрузить статистику",
							"disabled": true
						},
                      {
                        "key": "unique",
                        "value": "false",
                        "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)",
                        "disabled": true
                      }
                    ]
                }
            },
        "response": []
      },
      {
        "name": "Получение статистики по посещениям. (Тест на верную обработку запроса с неверными датами начала и конца диапазона времени)",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                ""
              ],
              "type": "text/javascript"
            }
          },
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                "    pm.response.to.be.badRequest;\r",
                "});"
              ],
              "type": "text/javascript"
            }
          }
        ],
        "request": {
          "method": "GET",
          "header": [
            {
              "key": "Accept",
              "value": "application/json"
            }
          ],
          "url": {
            "raw": "{{baseUrl}}/stats?start=2035-05-05 00:00:00&end=2020-05-05 00:00:00&uris={{uri}}",
            "host": [
              "{{baseUrl}}"
            ],
            "path": [
              "stats"
            ],
            "query": [
              {
                "key": "start",
                "value": "2035-05-05 00:00:00",
                "description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "end",
                "value": "2020-05-05 00:00:00",
                "description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "uris",
                "value": "{{uri}}",
                "description": "Список uri для которых нужно выгрузить статистику"
              },
              {
                "key": "unique",
                "value": "false",
                "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)",
                "disabled": true
              }
            ]
          }
        },
        "response": []
      },
      {
        "name": "Тест на верную обработку запроса без даты начала",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                ""
              ],
              "type": "text/javascript"
            }
          },
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                "    pm.response.to.be.badRequest;\r",
                "});"
              ],
              "type": "text/javascript"
            }
          }
        ],
        "request": {
          "method": "GET",
          "header": [
            {
              "key": "Accept",
              "value": "application/json"
            }
          ],
          "url": {
            "raw": "{{baseUrl}}/stats?end=2020-05-05 00:00:00&uris={{uri}}",
            "host": [
              "{{baseUrl}}"
            ],
            "path": [
              "stats"
            ],
            "query": [
              {
                "key": "start",
                "value": "2035-05-05 00:00:00",
                "description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")",
                "disabled": true
              },
              {
                "key": "end",
                "value": "2020-05-05 00:00:00",
                "description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "uris",
                "value": "{{uri}}",
                "description": "Список uri для которых нужно выгрузить статистику"
              },
              {
                "key": "unique",
                "value": "false",
                "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)",
                "disabled": true
              }
            ]
          }
        },
        "response": []
      },
      {
        "name": "Тест на верную обработку запроса без даты конца",
        "event": [
          {
            "listen": "prerequest",
            "script": {
              "exec": [
                ""
              ],
              "type": "text/javascript"
            }
          },
          {
            "listen": "test",
            "script": {
              "exec": [
                "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                "    pm.response.to.be.badRequest;\r",
                "});"
              ],
              "type": "text/javascript"
            }
          }
        ],
        "request": {
          "method": "GET",
          "header": [
            {
              "key": "Accept",
              "value": "application/json"
            }
          ],
          "url": {
            "raw": "{{baseUrl}}/stats?start=2035-05-05 00:00:00&uris={{uri}}",
            "host": [
              "{{baseUrl}}"
            ],
            "path": [
              "stats"
            ],
            "query": [
              {
                "key": "start",
                "value": "2035-05-05 00:00:00",
                "description": "(Required) Дата и время начала диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")"
              },
              {
                "key": "end",
                "value": "2020-05-05 00:00:00",
                "description": "(Required) Дата и время конца диапазона за который нужно выгрузить статистику (в формате \"yyyy-MM-dd HH:mm:ss\")",
                "disabled": true
              },
              {
                "key": "uris",
                "value": "{{uri}}",
                "description": "Список uri для которых нужно выгрузить статистику"
              },
              {
                "key": "unique",
                "value": "false",
                "description": "Нужно ли учитывать только уникальные посещения (только с уникальным ip)",
                "disabled": true
              }
            ]
          }
        },
        "response": []
      }
    ],
	"event": [
		{
			"listen": "prerequest",
			"script": {
				"type": "text/javascript",
				"exec": [
					"API = class {",
                  "    constructor(postman, verbose = false, baseUrl = \"http://localhost:9090\") {",
                  "        this.baseUrl = baseUrl;",
                  "        this.pm = postman;",
                  "        this._verbose = verbose;",
                  "    }",
                  "",
                  "    async addPost(post, verbose=null) {",
                  "        return this.post(\"/hit\", post, \"Ошибка при сохранении информации о запросе к эндпойнту: \", verbose);",
                  "    }",
                  "",
                  "    async addUser(user, verbose=null) {",
                  "        return this.post(\"/admin/users\", user, \"http://localhost:8080\", \"Ошибка при добавлении нового пользователя: \", verbose);",
                  "    }",
                  "",
                  "    async addCategory(category, verbose=null) {",
                  "        return this.post(\"/admin/categories\", category, \"http://localhost:8080\", \"Ошибка при добавлении новой категории: \", verbose);",
                  "    }",
                  "",
                  "    async addEvent(userId, event, verbose=null) {",
                  "        return this.post(\"/users/\" + userId + \"/events\", event, \"http://localhost:8080\", \"Ошибка при добавлении нового события: \", verbose);",
                  "    }",
                  "",
                  "    async publishEvent(eventId, verbose=null) {",
                  "        return this.patch('/admin/events/' + eventId, {stateAction: \"PUBLISH_EVENT\"},\"Ошибка при публикации события\", verbose);",
                  "    }",
                  "",
                  "    async patch(path, body = null, errorText = \"Ошибка при выполнении patch-запроса: \", verbose=null) {",
                  "        return this.sendRequest(\"PATCH\", path, \"http://localhost:8080\", body, errorText);",
                  "    }",
                  "",
                  "    async post(path, body, newBaseUrl=null, errorText = \"Ошибка при выполнении post-запроса: \", verbose=null) {",
                  "        return this.sendRequest(\"POST\", path, newBaseUrl, body, errorText);",
                  "    }",
                  "",
                  "    async sendRequest(method, path, newBaseUrl=null, body=null, errorText = \"Ошибка при выполнении запроса: \", verbose=null) {",
                  "        return new Promise((resolve, reject) => {",
                  "            verbose = verbose == null ? this._verbose : verbose;",
                  "            let request;",
                  "            if (newBaseUrl==null)",
                  "                 request = {",
                  "                    url: this.baseUrl + path,",
                  "                    method: method,",
                  "                    body: body == null ? \"\" : JSON.stringify(body),",
                  "                    header: { \"Content-Type\": \"application/json\" },",
                  "                };",
                  "            else",
                  "                request = {",
                  "                    url: newBaseUrl + path,",
                  "                    method: method,",
                  "                    body: body == null ? \"\" : JSON.stringify(body),",
                  "                    header: { \"Content-Type\": \"application/json\" },",
                  "                };",
                  "",
                  "            if(verbose) {",
                  "                console.log(\"Отправляю запрос: \", request);",
                  "            }",
                  "",
                  "            try {",
                  "                this.pm.sendRequest(request, (error, response) => {",
                  "                    if(error || (response.code >= 400 && response.code <= 599)) {",
                  "                        let err = error ? error : JSON.stringify(response.json());",
                  "                        console.error(\"При выполнении запроса к серверу возникла ошика.\\n\", err,",
					"                             \"\\nДля отладки проблемы повторите такой же запрос к вашей программе \" + ",
					"                             \"на локальном компьютере. Данные запроса:\\n\", JSON.stringify(request));",
					"",
					"                        reject(new Error(errorText + err));",
					"                    }",
					"",
					"                    if(verbose) {",
					"                        console.log(\"Результат обработки запроса: код состояния - \", response.code, \", тело: \", response.json());",
					"                    }",
					"                    try{",
					"                        resolve(response.json());",
					"                    } catch(err){",
					"                        resolve(response);",
					"                    }",
					"                    ",
					"                });",
					"            } catch(err) {",
					"                if(verbose) {",
					"                    console.error(errorText, err);",
					"                }",
					"                return Promise.reject(err);",
					"            }",
					"        });",
                  "    }",
                  "};",
                  "",
                  "RandomUtils = class {",
                  "    constructor() {}",
                  "",
                  "    getPost() {",
                  "        return {",
                  "            app: \"ewm-main-service\",",
                  "            uri: \"/events/\" + pm.variables.replaceIn('{{$randomInt}}'),",
                  "            ip: pm.variables.replaceIn('{{$randomIP}}'),",
                  "            timestamp: this.getPastDateTime()",
                  "        }",
                  "    }",
                  "",
                  "     getUser() {",
                  "        return {",
                  "            name: pm.variables.replaceIn('{{$randomFullName}}'),",
                  "            email: pm.variables.replaceIn('{{$randomEmail}}')",
                  "        };",
                  "    }",
                  "",
                  "    getCategory() {",
                  "        return {",
                  "            name: pm.variables.replaceIn('{{$randomWord}}') + Math.floor(Math.random() * 100).toString()",
                  "        };",
                  "    }",
                  "",
                  "    getEvent(categoryId) {",
                  "        return {",
                  "            annotation: pm.variables.replaceIn('{{$randomLoremParagraph}}'),",
                  "            category: categoryId,",
                  "            description: pm.variables.replaceIn('{{$randomLoremParagraphs}}'),",
                  "            eventDate: this.getFutureDateTime(),",
                  "            location: {",
                  "                lat: parseFloat(pm.variables.replaceIn('{{$randomLatitude}}')),",
                  "                lon: parseFloat(pm.variables.replaceIn('{{$randomLongitude}}')),",
                  "            },",
                  "            paid: pm.variables.replaceIn('{{$randomBoolean}}'),",
                  "            participantLimit: pm.variables.replaceIn('{{$randomInt}}'),",
                  "            requestModeration: pm.variables.replaceIn('{{$randomBoolean}}'),",
                  "            title: pm.variables.replaceIn('{{$randomLoremSentence}}'),",
                  "        }",
                  "    }",
                  "    ",
                  "    getCompilation(...eventIds) { ",
                  "        return { ",
                  "            title: pm.variables.replaceIn('{{$randomLoremSentence}}'), ",
                  "            pinned: pm.variables.replaceIn('{{$randomBoolean}}'), ",
                  "            events: eventIds ",
                  "        }; ",
                  "    }",
                  "",
                  "    getPastDateTime(hourShift = 5, minuteShift=0, yearShift=0) {",
                  "        let moment = require('moment');",
                  "",
                  "        let m = moment();",
                  "        m.subtract(hourShift, 'hour');",
                  "        m.subtract(minuteShift, 'minute');",
                  "        m.subtract(yearShift, 'year');",
                  "",
                  "        return m.format('YYYY-MM-DD HH:mm:ss');",
                  "    }",
                  "",
                  "    getFutureDateTime(hourShift = 5, minuteShift=0, yearShift=0) {",
                  "        let moment = require('moment');",
                  "",
                  "        let m = moment();",
                  "        m.add(hourShift, 'hour');",
                  "        m.add(minuteShift, 'minute');",
                  "        m.add(yearShift, 'year');",
                  "",
                  "        return m.format('YYYY-MM-DD HH:mm:ss');",
                  "    }",
                  "}"
                ]
			}
		},
		{
			"listen": "test",
			"script": {
				"type": "text/javascript",
				"exec": [
					""
				]
			}
		}
	],
	"variable": [
		{
			"key": "baseUrl",
			"value": "http://localhost:9090",
			"type": "string"
		},
		{
			"key": "uri",
			"value": "1"
		},
		{
			"key": "source",
			"value": ""
		}
	]
}
